<?php
/**
* Smarty Internal Plugin Configfileparser
*
* This is the config file parser.
* It is generated from the internal.configfileparser.y file
* @package Smarty
* @subpackage Compiler
* @author Uwe Tews
*/

class TPC_yyToken implements ArrayAccess {
	public $string = '';
	public $metadata = array ();
	
	function __construct($s, $m = array()) {
		if ($s instanceof TPC_yyToken) {
			$this->string = $s->string;
			$this->metadata = $s->metadata;
		} else {
			$this->string = ( string ) $s;
			if ($m instanceof TPC_yyToken) {
				$this->metadata = $m->metadata;
			} elseif (is_array ( $m )) {
				$this->metadata = $m;
			}
		}
	}
	
	function __toString() {
		return $this->_string;
	}
	
	function offsetExists($offset) {
		return isset ( $this->metadata [$offset] );
	}
	
	function offsetGet($offset) {
		return $this->metadata [$offset];
	}
	
	function offsetSet($offset, $value) {
		if ($offset === null) {
			if (isset ( $value [0] )) {
				$x = ($value instanceof TPC_yyToken) ? $value->metadata : $value;
				$this->metadata = array_merge ( $this->metadata, $x );
				return;
			}
			$offset = count ( $this->metadata );
		}
		if ($value === null) {
			return;
		}
		if ($value instanceof TPC_yyToken) {
			if ($value->metadata) {
				$this->metadata [$offset] = $value->metadata;
			}
		} elseif ($value) {
			$this->metadata [$offset] = $value;
		}
	}
	
	function offsetUnset($offset) {
		unset ( $this->metadata [$offset] );
	}
}

class TPC_yyStackEntry {
	public $stateno; /*
	                  * The state-number
	                  */
	public $major; /*
	                * The major token value. This is the code * number for the
	                * token at this stack level
	                */
	public $minor; /*
	                * The user-supplied minor token value. This * is the value of
	                * the token
	                */
}
;

// ine 12 "smarty_internal_configfileparser.y"
class Smarty_Internal_Configfileparser // ine 79
                                       // "smarty_internal_configfileparser.php"
{
	// ine 14 "smarty_internal_configfileparser.y"
	
	// states whether the parse was successful or not
	public $successful = true;
	public $retvalue = 0;
	private $lex;
	private $internalError = false;
	
	function __construct($lex, $compiler) {
		// set instance object
		self::instance ( $this );
		$this->lex = $lex;
		$this->smarty = $compiler->smarty;
		$this->compiler = $compiler;
	}
	public static function &instance($new_instance = null) {
		static $instance = null;
		if (isset ( $new_instance ) && is_object ( $new_instance ))
			$instance = $new_instance;
		return $instance;
	}
	
	private function parse_bool($str) {
		if (in_array ( strtolower ( $str ), array ('on', 'yes', 'true' ) )) {
			$res = true;
		} else {
			$res = false;
		}
		return $res;
	}
	
	private static $escapes_single = Array ('\\' => '\\', '\'' => '\'' );
	private static function parse_single_quoted_string($qstr) {
		$escaped_string = substr ( $qstr, 1, strlen ( $qstr ) - 2 ); // remove outer
		                                                     // quotes
		
		$ss = preg_split ( '/(\\\\.)/', $escaped_string, - 1, PREG_SPLIT_DELIM_CAPTURE );
		
		$str = "";
		foreach ( $ss as $s ) {
			if (strlen ( $s ) === 2 && $s [0] === '\\') {
				if (isset ( self::$escapes_single [$s [1]] )) {
					$s = self::$escapes_single [$s [1]];
				}
			}
			
			$str .= $s;
		}
		
		return $str;
	}
	
	private static function parse_double_quoted_string($qstr) {
		$inner_str = substr ( $qstr, 1, strlen ( $qstr ) - 2 );
		return stripcslashes ( $inner_str );
	}
	
	private static function parse_tripple_double_quoted_string($qstr) {
		return stripcslashes ( $qstr );
	}
	
	private function set_var(Array $var, Array &$target_array) {
		$key = $var ["key"];
		$value = $var ["value"];
		
		if ($this->smarty->config_overwrite || ! isset ( $target_array ['vars'] [$key] )) {
			$target_array ['vars'] [$key] = $value;
		} else {
			settype ( $target_array ['vars'] [$key], 'array' );
			$target_array ['vars'] [$key] [] = $value;
		}
	}
	
	private function add_global_vars(Array $vars) {
		if (! isset ( $this->compiler->config_data ['vars'] )) {
			$this->compiler->config_data ['vars'] = Array ();
		}
		foreach ( $vars as $var ) {
			$this->set_var ( $var, $this->compiler->config_data );
		}
	}
	
	private function add_section_vars($section_name, Array $vars) {
		if (! isset ( $this->compiler->config_data ['sections'] [$section_name] ['vars'] )) {
			$this->compiler->config_data ['sections'] [$section_name] ['vars'] = Array ();
		}
		foreach ( $vars as $var ) {
			$this->set_var ( $var, $this->compiler->config_data ['sections'] [$section_name] );
		}
	}
	// ine 173 "smarty_internal_configfileparser.php"
	
	const TPC_OPENB = 1;
	const TPC_SECTION = 2;
	const TPC_CLOSEB = 3;
	const TPC_DOT = 4;
	const TPC_ID = 5;
	const TPC_EQUAL = 6;
	const TPC_FLOAT = 7;
	const TPC_INT = 8;
	const TPC_BOOL = 9;
	const TPC_SINGLE_QUOTED_STRING = 10;
	const TPC_DOUBLE_QUOTED_STRING = 11;
	const TPC_TRIPPLE_QUOTES = 12;
	const TPC_TRIPPLE_TEXT = 13;
	const TPC_TRIPPLE_QUOTES_END = 14;
	const TPC_NAKED_STRING = 15;
	const TPC_OTHER = 16;
	const TPC_NEWLINE = 17;
	const TPC_COMMENTSTART = 18;
	const YY_NO_ACTION = 60;
	const YY_ACCEPT_ACTION = 59;
	const YY_ERROR_ACTION = 58;
	
	const YY_SZ_ACTTAB = 38;
	public static $yy_action = array(
 /*     0 */    29, 30, 34, 33, 24, 13, 19, 25, 35, 21,
 /*    10 */    59, 8, 3, 1, 20, 12, 14, 31, 20, 12,
 /*    20 */    15, 17, 23, 18, 27, 26, 4, 5, 6, 32,
 /*    30 */     2, 11, 28, 22, 16, 9, 7, 10 );
	public static $yy_lookahead = array(
 /*     0 */     7, 8, 9, 10, 11, 12, 5, 27, 15, 16,
 /*    10 */    20, 21, 23, 23, 17, 18, 13, 14, 17, 18,
 /*    20 */    15, 2, 17, 4, 25, 26, 6, 3, 3, 14,
 /*    30 */    23, 1, 24, 17, 2, 25, 22, 25 );
	const YY_SHIFT_USE_DFLT = - 8;
	const YY_SHIFT_MAX = 19;
	public static $yy_shift_ofst = array(
 /*     0 */    - 8, 1, 1, 1, - 7, - 3, - 3, 30, - 8, - 8,
 /*    10 */    - 8, 19, 5, 3, 15, 16, 24, 25, 32, 20 );
	const YY_REDUCE_USE_DFLT = - 21;
	const YY_REDUCE_MAX = 10;
	public static $yy_reduce_ofst = array(
 /*     0 */   - 10, - 1, - 1, - 1, - 20, 10, 12, 8, 14, 7,
 /*    10 */   - 11 );
	public static $yyExpectedTokens = array(
        /* 0 */ array (),
        /* 1 */ array (5, 17, 18 ),
        /* 2 */ array (5, 17, 18 ),
        /* 3 */ array (5, 17, 18 ),
        /* 4 */ array (7, 8, 9, 10, 11, 12, 15, 16 ),
        /* 5 */ array (17, 18 ),
        /* 6 */ array (17, 18 ),
        /* 7 */ array (1 ),
        /* 8 */ array (),
        /* 9 */ array (),
        /* 10 */ array (),
        /* 11 */ array (2, 4 ),
        /* 12 */ array (15, 17 ),
        /* 13 */ array (13, 14 ),
        /* 14 */ array (14 ),
        /* 15 */ array (17 ),
        /* 16 */ array (3 ),
        /* 17 */ array (3 ),
        /* 18 */ array (2 ),
        /* 19 */ array (6 ),
        /* 20 */ array (),
        /* 21 */ array (),
        /* 22 */ array (),
        /* 23 */ array (),
        /* 24 */ array (),
        /* 25 */ array (),
        /* 26 */ array (),
        /* 27 */ array (),
        /* 28 */ array (),
        /* 29 */ array (),
        /* 30 */ array (),
        /* 31 */ array (),
        /* 32 */ array (),
        /* 33 */ array (),
        /* 34 */ array (),
        /* 35 */ array () );
	public static $yy_default = array(
 /*     0 */    44, 37, 41, 40, 58, 58, 58, 36, 39, 44,
 /*    10 */    44, 58, 58, 58, 58, 58, 58, 58, 58, 58,
 /*    20 */    55, 54, 57, 56, 50, 45, 43, 42, 38, 46,
 /*    30 */    47, 52, 51, 49, 48, 53 );
	const YYNOCODE = 29;
	const YYSTACKDEPTH = 100;
	const YYNSTATE = 36;
	const YYNRULE = 22;
	const YYERRORSYMBOL = 19;
	const YYERRSYMDT = 'yy0';
	const YYFALLBACK = 0;
	public static $yyFallback = array ();
	static function Trace($TraceFILE, $zTracePrompt) {
		if (! $TraceFILE) {
			$zTracePrompt = 0;
		} elseif (! $zTracePrompt) {
			$TraceFILE = 0;
		}
		self::$yyTraceFILE = $TraceFILE;
		self::$yyTracePrompt = $zTracePrompt;
	}
	
	static function PrintTrace() {
		self::$yyTraceFILE = fopen ( 'php://output', 'w' );
		self::$yyTracePrompt = '<br>';
	}
	
	public static $yyTraceFILE;
	public static $yyTracePrompt;
	public $yyidx; /*
	                * Index of top element in stack
	                */
	public $yyerrcnt; /*
	                   * Shifts left before out of the error
	                   */
	public $yystack = array (); /*
	                            * The parser's stack
	                            */
	
	public $yyTokenName = array ('$', 'OPENB', 'SECTION', 'CLOSEB', 'DOT', 'ID', 'EQUAL', 'FLOAT', 'INT', 'BOOL', 'SINGLE_QUOTED_STRING', 'DOUBLE_QUOTED_STRING', 'TRIPPLE_QUOTES', 'TRIPPLE_TEXT', 'TRIPPLE_QUOTES_END', 'NAKED_STRING', 'OTHER', 'NEWLINE', 'COMMENTSTART', 'error', 'start', 'global_vars', 'sections', 'var_list', 'section', 'newline', 'var', 'value' );
	
	public static $yyRuleName = array(
 /*   0 */ "start ::= global_vars sections",
 /*   1 */ "global_vars ::= var_list",
 /*   2 */ "sections ::= sections section",
 /*   3 */ "sections ::=",
 /*   4 */ "section ::= OPENB SECTION CLOSEB newline var_list",
 /*   5 */ "section ::= OPENB DOT SECTION CLOSEB newline var_list",
 /*   6 */ "var_list ::= var_list newline",
 /*   7 */ "var_list ::= var_list var",
 /*   8 */ "var_list ::=",
 /*   9 */ "var ::= ID EQUAL value",
 /*  10 */ "value ::= FLOAT",
 /*  11 */ "value ::= INT",
 /*  12 */ "value ::= BOOL",
 /*  13 */ "value ::= SINGLE_QUOTED_STRING",
 /*  14 */ "value ::= DOUBLE_QUOTED_STRING",
 /*  15 */ "value ::= TRIPPLE_QUOTES TRIPPLE_TEXT TRIPPLE_QUOTES_END",
 /*  16 */ "value ::= TRIPPLE_QUOTES TRIPPLE_QUOTES_END",
 /*  17 */ "value ::= NAKED_STRING",
 /*  18 */ "value ::= OTHER",
 /*  19 */ "newline ::= NEWLINE",
 /*  20 */ "newline ::= COMMENTSTART NEWLINE",
 /*  21 */ "newline ::= COMMENTSTART NAKED_STRING NEWLINE" );
	
	function tokenName($tokenType) {
		if ($tokenType === 0) {
			return 'End of Input';
		}
		if ($tokenType > 0 && $tokenType < count ( $this->yyTokenName )) {
			return $this->yyTokenName [$tokenType];
		} else {
			return "Unknown";
		}
	}
	
	static function yy_destructor($yymajor, $yypminor) {
		switch ($yymajor) {
			default :
				break; /*
				                  * If no destructor action specified: do nothing
				                  */
		}
	}
	
	function yy_pop_parser_stack() {
		if (! count ( $this->yystack )) {
			return;
		}
		$yytos = array_pop ( $this->yystack );
		if (self::$yyTraceFILE && $this->yyidx >= 0) {
			fwrite ( self::$yyTraceFILE, self::$yyTracePrompt . 'Popping ' . $this->yyTokenName [$yytos->major] . "\n" );
		}
		$yymajor = $yytos->major;
		self::yy_destructor ( $yymajor, $yytos->minor );
		$this->yyidx --;
		return $yymajor;
	}
	
	function __destruct() {
		while ( $this->yystack !== Array () ) {
			$this->yy_pop_parser_stack ();
		}
		if (is_resource ( self::$yyTraceFILE )) {
			fclose ( self::$yyTraceFILE );
		}
	}
	
	function yy_get_expected_tokens($token) {
		$state = $this->yystack [$this->yyidx]->stateno;
		$expected = self::$yyExpectedTokens [$state];
		if (in_array ( $token, self::$yyExpectedTokens [$state], true )) {
			return $expected;
		}
		$stack = $this->yystack;
		$yyidx = $this->yyidx;
		do {
			$yyact = $this->yy_find_shift_action ( $token );
			if ($yyact >= self::YYNSTATE && $yyact < self::YYNSTATE + self::YYNRULE) {
				// reduce action
				$done = 0;
				do {
					if ($done ++ == 100) {
						$this->yyidx = $yyidx;
						$this->yystack = $stack;
						// too much recursion prevents proper detection
						// so give up
						return array_unique ( $expected );
					}
					$yyruleno = $yyact - self::YYNSTATE;
					$this->yyidx -= self::$yyRuleInfo [$yyruleno] ['rhs'];
					$nextstate = $this->yy_find_reduce_action ( $this->yystack [$this->yyidx]->stateno, self::$yyRuleInfo [$yyruleno] ['lhs'] );
					if (isset ( self::$yyExpectedTokens [$nextstate] )) {
						$expected = array_merge ( $expected, self::$yyExpectedTokens [$nextstate] );
						if (in_array ( $token, self::$yyExpectedTokens [$nextstate], true )) {
							$this->yyidx = $yyidx;
							$this->yystack = $stack;
							return array_unique ( $expected );
						}
					}
					if ($nextstate < self::YYNSTATE) {
						// we need to shift a non-terminal
						$this->yyidx ++;
						$x = new TPC_yyStackEntry ();
						$x->stateno = $nextstate;
						$x->major = self::$yyRuleInfo [$yyruleno] ['lhs'];
						$this->yystack [$this->yyidx] = $x;
						continue 2;
					} elseif ($nextstate == self::YYNSTATE + self::YYNRULE + 1) {
						$this->yyidx = $yyidx;
						$this->yystack = $stack;
						// the last token was just ignored, we can't accept
						// by ignoring input, this is in essence ignoring a
						// syntax error!
						return array_unique ( $expected );
					} elseif ($nextstate === self::YY_NO_ACTION) {
						$this->yyidx = $yyidx;
						$this->yystack = $stack;
						// input accepted, but not shifted (I guess)
						return $expected;
					} else {
						$yyact = $nextstate;
					}
				} while ( true );
			}
			break;
		} while ( true );
		$this->yyidx = $yyidx;
		$this->yystack = $stack;
		return array_unique ( $expected );
	}
	
	function yy_is_expected_token($token) {
		if ($token === 0) {
			return true; // 0 is not part of this
		}
		$state = $this->yystack [$this->yyidx]->stateno;
		if (in_array ( $token, self::$yyExpectedTokens [$state], true )) {
			return true;
		}
		$stack = $this->yystack;
		$yyidx = $this->yyidx;
		do {
			$yyact = $this->yy_find_shift_action ( $token );
			if ($yyact >= self::YYNSTATE && $yyact < self::YYNSTATE + self::YYNRULE) {
				// reduce action
				$done = 0;
				do {
					if ($done ++ == 100) {
						$this->yyidx = $yyidx;
						$this->yystack = $stack;
						// too much recursion prevents proper detection
						// so give up
						return true;
					}
					$yyruleno = $yyact - self::YYNSTATE;
					$this->yyidx -= self::$yyRuleInfo [$yyruleno] ['rhs'];
					$nextstate = $this->yy_find_reduce_action ( $this->yystack [$this->yyidx]->stateno, self::$yyRuleInfo [$yyruleno] ['lhs'] );
					if (isset ( self::$yyExpectedTokens [$nextstate] ) && in_array ( $token, self::$yyExpectedTokens [$nextstate], true )) {
						$this->yyidx = $yyidx;
						$this->yystack = $stack;
						return true;
					}
					if ($nextstate < self::YYNSTATE) {
						// we need to shift a non-terminal
						$this->yyidx ++;
						$x = new TPC_yyStackEntry ();
						$x->stateno = $nextstate;
						$x->major = self::$yyRuleInfo [$yyruleno] ['lhs'];
						$this->yystack [$this->yyidx] = $x;
						continue 2;
					} elseif ($nextstate == self::YYNSTATE + self::YYNRULE + 1) {
						$this->yyidx = $yyidx;
						$this->yystack = $stack;
						if (! $token) {
							// end of input: this is valid
							return true;
						}
						// the last token was just ignored, we can't accept
						// by ignoring input, this is in essence ignoring a
						// syntax error!
						return false;
					} elseif ($nextstate === self::YY_NO_ACTION) {
						$this->yyidx = $yyidx;
						$this->yystack = $stack;
						// input accepted, but not shifted (I guess)
						return true;
					} else {
						$yyact = $nextstate;
					}
				} while ( true );
			}
			break;
		} while ( true );
		$this->yyidx = $yyidx;
		$this->yystack = $stack;
		return true;
	}
	
	function yy_find_shift_action($iLookAhead) {
		$stateno = $this->yystack [$this->yyidx]->stateno;
		
		/*
		 * if ($this->yyidx < 0) return self::YY_NO_ACTION;
		 */
		if (! isset ( self::$yy_shift_ofst [$stateno] )) {
			// no shift actions
			return self::$yy_default [$stateno];
		}
		$i = self::$yy_shift_ofst [$stateno];
		if ($i === self::YY_SHIFT_USE_DFLT) {
			return self::$yy_default [$stateno];
		}
		if ($iLookAhead == self::YYNOCODE) {
			return self::YY_NO_ACTION;
		}
		$i += $iLookAhead;
		if ($i < 0 || $i >= self::YY_SZ_ACTTAB || self::$yy_lookahead [$i] != $iLookAhead) {
			if (count ( self::$yyFallback ) && $iLookAhead < count ( self::$yyFallback ) && ($iFallback = self::$yyFallback [$iLookAhead]) != 0) {
				if (self::$yyTraceFILE) {
					fwrite ( self::$yyTraceFILE, self::$yyTracePrompt . "FALLBACK " . $this->yyTokenName [$iLookAhead] . " => " . $this->yyTokenName [$iFallback] . "\n" );
				}
				return $this->yy_find_shift_action ( $iFallback );
			}
			return self::$yy_default [$stateno];
		} else {
			return self::$yy_action [$i];
		}
	}
	
	function yy_find_reduce_action($stateno, $iLookAhead) {
		/*
		 * $stateno = $this->yystack[$this->yyidx]->stateno;
		 */
		
		if (! isset ( self::$yy_reduce_ofst [$stateno] )) {
			return self::$yy_default [$stateno];
		}
		$i = self::$yy_reduce_ofst [$stateno];
		if ($i == self::YY_REDUCE_USE_DFLT) {
			return self::$yy_default [$stateno];
		}
		if ($iLookAhead == self::YYNOCODE) {
			return self::YY_NO_ACTION;
		}
		$i += $iLookAhead;
		if ($i < 0 || $i >= self::YY_SZ_ACTTAB || self::$yy_lookahead [$i] != $iLookAhead) {
			return self::$yy_default [$stateno];
		} else {
			return self::$yy_action [$i];
		}
	}
	
	function yy_shift($yyNewState, $yyMajor, $yypMinor) {
		$this->yyidx ++;
		if ($this->yyidx >= self::YYSTACKDEPTH) {
			$this->yyidx --;
			if (self::$yyTraceFILE) {
				fprintf ( self::$yyTraceFILE, "%sStack Overflow!\n", self::$yyTracePrompt );
			}
			while ( $this->yyidx >= 0 ) {
				$this->yy_pop_parser_stack ();
			}
			// ine 125 "smarty_internal_configfileparser.y"
			
			$this->internalError = true;
			$this->compiler->trigger_config_file_error ( "Stack overflow in configfile parser" );
			// ine 593 "smarty_internal_configfileparser.php"
			return;
		}
		$yytos = new TPC_yyStackEntry ();
		$yytos->stateno = $yyNewState;
		$yytos->major = $yyMajor;
		$yytos->minor = $yypMinor;
		array_push ( $this->yystack, $yytos );
		if (self::$yyTraceFILE && $this->yyidx > 0) {
			fprintf ( self::$yyTraceFILE, "%sShift %d\n", self::$yyTracePrompt, $yyNewState );
			fprintf ( self::$yyTraceFILE, "%sStack:", self::$yyTracePrompt );
			for($i = 1; $i <= $this->yyidx; $i ++) {
				fprintf ( self::$yyTraceFILE, " %s", $this->yyTokenName [$this->yystack [$i]->major] );
			}
			fwrite ( self::$yyTraceFILE, "\n" );
		}
	}
	
	public static $yyRuleInfo = array (array ('lhs' => 20, 'rhs' => 2 ), array ('lhs' => 21, 'rhs' => 1 ), array ('lhs' => 22, 'rhs' => 2 ), array ('lhs' => 22, 'rhs' => 0 ), array ('lhs' => 24, 'rhs' => 5 ), array ('lhs' => 24, 'rhs' => 6 ), array ('lhs' => 23, 'rhs' => 2 ), array ('lhs' => 23, 'rhs' => 2 ), array ('lhs' => 23, 'rhs' => 0 ), array ('lhs' => 26, 'rhs' => 3 ), array ('lhs' => 27, 'rhs' => 1 ), array ('lhs' => 27, 'rhs' => 1 ), array ('lhs' => 27, 'rhs' => 1 ), array ('lhs' => 27, 'rhs' => 1 ), array ('lhs' => 27, 'rhs' => 1 ), array ('lhs' => 27, 'rhs' => 3 ), array ('lhs' => 27, 'rhs' => 2 ), array ('lhs' => 27, 'rhs' => 1 ), array ('lhs' => 27, 'rhs' => 1 ), array ('lhs' => 25, 'rhs' => 1 ), array ('lhs' => 25, 'rhs' => 2 ), array ('lhs' => 25, 'rhs' => 3 ) );
	
	public static $yyReduceMap = array (0 => 0, 2 => 0, 3 => 0, 19 => 0, 20 => 0, 21 => 0, 1 => 1, 4 => 4, 5 => 5, 6 => 6, 7 => 7, 8 => 8, 9 => 9, 10 => 10, 11 => 11, 12 => 12, 13 => 13, 14 => 14, 15 => 15, 16 => 16, 17 => 17, 18 => 17 );
	// ine 131 "smarty_internal_configfileparser.y"
	function yy_r0() {
		$this->_retvalue = null;
	}
	// ine 666 "smarty_internal_configfileparser.php"
	// ine 136 "smarty_internal_configfileparser.y"
	function yy_r1() {
		$this->add_global_vars ( $this->yystack [$this->yyidx + 0]->minor );
		$this->_retvalue = null;
	}
	// ine 671 "smarty_internal_configfileparser.php"
	// ine 149 "smarty_internal_configfileparser.y"
	function yy_r4() {
		$this->add_section_vars ( $this->yystack [$this->yyidx + - 3]->minor, $this->yystack [$this->yyidx + 0]->minor );
		$this->_retvalue = null;
	}
	// ine 677 "smarty_internal_configfileparser.php"
	// ine 154 "smarty_internal_configfileparser.y"
	function yy_r5() {
		if ($this->smarty->config_read_hidden) {
			$this->add_section_vars ( $this->yystack [$this->yyidx + - 3]->minor, $this->yystack [$this->yyidx + 0]->minor );
		}
		$this->_retvalue = null;
	}
	// ine 685 "smarty_internal_configfileparser.php"
	// ine 162 "smarty_internal_configfileparser.y"
	function yy_r6() {
		$this->_retvalue = $this->yystack [$this->yyidx + - 1]->minor;
	}
	// ine 690 "smarty_internal_configfileparser.php"
	// ine 166 "smarty_internal_configfileparser.y"
	function yy_r7() {
		$this->_retvalue = array_merge ( $this->yystack [$this->yyidx + - 1]->minor, Array ($this->yystack [$this->yyidx + 0]->minor ) );
	}
	// ine 695 "smarty_internal_configfileparser.php"
	// ine 170 "smarty_internal_configfileparser.y"
	function yy_r8() {
		$this->_retvalue = Array ();
	}
	// ine 700 "smarty_internal_configfileparser.php"
	// ine 176 "smarty_internal_configfileparser.y"
	function yy_r9() {
		$this->_retvalue = Array ("key" => $this->yystack [$this->yyidx + - 2]->minor, "value" => $this->yystack [$this->yyidx + 0]->minor );
	}
	// ine 705 "smarty_internal_configfileparser.php"
	// ine 181 "smarty_internal_configfileparser.y"
	function yy_r10() {
		$this->_retvalue = ( float ) $this->yystack [$this->yyidx + 0]->minor;
	}
	// ine 710 "smarty_internal_configfileparser.php"
	// ine 185 "smarty_internal_configfileparser.y"
	function yy_r11() {
		$this->_retvalue = ( int ) $this->yystack [$this->yyidx + 0]->minor;
	}
	// ine 715 "smarty_internal_configfileparser.php"
	// ine 189 "smarty_internal_configfileparser.y"
	function yy_r12() {
		$this->_retvalue = $this->parse_bool ( $this->yystack [$this->yyidx + 0]->minor );
	}
	// ine 720 "smarty_internal_configfileparser.php"
	// ine 193 "smarty_internal_configfileparser.y"
	function yy_r13() {
		$this->_retvalue = self::parse_single_quoted_string ( $this->yystack [$this->yyidx + 0]->minor );
	}
	// ine 725 "smarty_internal_configfileparser.php"
	// ine 197 "smarty_internal_configfileparser.y"
	function yy_r14() {
		$this->_retvalue = self::parse_double_quoted_string ( $this->yystack [$this->yyidx + 0]->minor );
	}
	// ine 730 "smarty_internal_configfileparser.php"
	// ine 201 "smarty_internal_configfileparser.y"
	function yy_r15() {
		$this->_retvalue = self::parse_tripple_double_quoted_string ( $this->yystack [$this->yyidx + - 1]->minor );
	}
	// ine 735 "smarty_internal_configfileparser.php"
	// ine 205 "smarty_internal_configfileparser.y"
	function yy_r16() {
		$this->_retvalue = '';
	}
	// ine 740 "smarty_internal_configfileparser.php"
	// ine 209 "smarty_internal_configfileparser.y"
	function yy_r17() {
		$this->_retvalue = $this->yystack [$this->yyidx + 0]->minor;
	}
	// ine 745 "smarty_internal_configfileparser.php"
	
	private $_retvalue;
	
	function yy_reduce($yyruleno) {
		$yymsp = $this->yystack [$this->yyidx];
		if (self::$yyTraceFILE && $yyruleno >= 0 && $yyruleno < count ( self::$yyRuleName )) {
			fprintf ( self::$yyTraceFILE, "%sReduce (%d) [%s].\n", self::$yyTracePrompt, $yyruleno, self::$yyRuleName [$yyruleno] );
		}
		
		$this->_retvalue = $yy_lefthand_side = null;
		if (array_key_exists ( $yyruleno, self::$yyReduceMap )) {
			// call the action
			$this->_retvalue = null;
			$this->{'yy_r' . self::$yyReduceMap [$yyruleno]} ();
			$yy_lefthand_side = $this->_retvalue;
		}
		$yygoto = self::$yyRuleInfo [$yyruleno] ['lhs'];
		$yysize = self::$yyRuleInfo [$yyruleno] ['rhs'];
		$this->yyidx -= $yysize;
		for($i = $yysize; $i; $i --) {
			// pop all of the right-hand side parameters
			array_pop ( $this->yystack );
		}
		$yyact = $this->yy_find_reduce_action ( $this->yystack [$this->yyidx]->stateno, $yygoto );
		if ($yyact < self::YYNSTATE) {
			if (! self::$yyTraceFILE && $yysize) {
				$this->yyidx ++;
				$x = new TPC_yyStackEntry ();
				$x->stateno = $yyact;
				$x->major = $yygoto;
				$x->minor = $yy_lefthand_side;
				$this->yystack [$this->yyidx] = $x;
			} else {
				$this->yy_shift ( $yyact, $yygoto, $yy_lefthand_side );
			}
		} elseif ($yyact == self::YYNSTATE + self::YYNRULE + 1) {
			$this->yy_accept ();
		}
	}
	
	function yy_parse_failed() {
		if (self::$yyTraceFILE) {
			fprintf ( self::$yyTraceFILE, "%sFail!\n", self::$yyTracePrompt );
		}
		while ( $this->yyidx >= 0 ) {
			$this->yy_pop_parser_stack ();
		}
	}
	
	function yy_syntax_error($yymajor, $TOKEN) {
		// ine 118 "smarty_internal_configfileparser.y"
		
		$this->internalError = true;
		$this->yymajor = $yymajor;
		$this->compiler->trigger_config_file_error ();
		// ine 808 "smarty_internal_configfileparser.php"
	}
	
	function yy_accept() {
		if (self::$yyTraceFILE) {
			fprintf ( self::$yyTraceFILE, "%sAccept!\n", self::$yyTracePrompt );
		}
		while ( $this->yyidx >= 0 ) {
			$stack = $this->yy_pop_parser_stack ();
		}
		// ine 110 "smarty_internal_configfileparser.y"
		
		$this->successful = ! $this->internalError;
		$this->internalError = false;
		$this->retvalue = $this->_retvalue;
		// echo $this->retvalue."\n\n";
		// ine 826 "smarty_internal_configfileparser.php"
	}
	
	function doParse($yymajor, $yytokenvalue) {
		$yyerrorhit = 0; /*
		                  * True if yymajor has invoked an error
		                  */
		
		if ($this->yyidx === null || $this->yyidx < 0) {
			$this->yyidx = 0;
			$this->yyerrcnt = - 1;
			$x = new TPC_yyStackEntry ();
			$x->stateno = 0;
			$x->major = 0;
			$this->yystack = array ();
			array_push ( $this->yystack, $x );
		}
		$yyendofinput = ($yymajor == 0);
		
		if (self::$yyTraceFILE) {
			fprintf ( self::$yyTraceFILE, "%sInput %s\n", self::$yyTracePrompt, $this->yyTokenName [$yymajor] );
		}
		
		do {
			$yyact = $this->yy_find_shift_action ( $yymajor );
			if ($yymajor < self::YYERRORSYMBOL && ! $this->yy_is_expected_token ( $yymajor )) {
				// force a syntax error
				$yyact = self::YY_ERROR_ACTION;
			}
			if ($yyact < self::YYNSTATE) {
				$this->yy_shift ( $yyact, $yymajor, $yytokenvalue );
				$this->yyerrcnt --;
				if ($yyendofinput && $this->yyidx >= 0) {
					$yymajor = 0;
				} else {
					$yymajor = self::YYNOCODE;
				}
			} elseif ($yyact < self::YYNSTATE + self::YYNRULE) {
				$this->yy_reduce ( $yyact - self::YYNSTATE );
			} elseif ($yyact == self::YY_ERROR_ACTION) {
				if (self::$yyTraceFILE) {
					fprintf ( self::$yyTraceFILE, "%sSyntax Error!\n", self::$yyTracePrompt );
				}
				if (self::YYERRORSYMBOL) {
					if ($this->yyerrcnt < 0) {
						$this->yy_syntax_error ( $yymajor, $yytokenvalue );
					}
					$yymx = $this->yystack [$this->yyidx]->major;
					if ($yymx == self::YYERRORSYMBOL || $yyerrorhit) {
						if (self::$yyTraceFILE) {
							fprintf ( self::$yyTraceFILE, "%sDiscard input token %s\n", self::$yyTracePrompt, $this->yyTokenName [$yymajor] );
						}
						$this->yy_destructor ( $yymajor, $yytokenvalue );
						$yymajor = self::YYNOCODE;
					} else {
						while ( $this->yyidx >= 0 && $yymx != self::YYERRORSYMBOL && ($yyact = $this->yy_find_shift_action ( self::YYERRORSYMBOL )) >= self::YYNSTATE ) {
							$this->yy_pop_parser_stack ();
						}
						if ($this->yyidx < 0 || $yymajor == 0) {
							$this->yy_destructor ( $yymajor, $yytokenvalue );
							$this->yy_parse_failed ();
							$yymajor = self::YYNOCODE;
						} elseif ($yymx != self::YYERRORSYMBOL) {
							$u2 = 0;
							$this->yy_shift ( $yyact, self::YYERRORSYMBOL, $u2 );
						}
					}
					$this->yyerrcnt = 3;
					$yyerrorhit = 1;
				} else {
					if ($this->yyerrcnt <= 0) {
						$this->yy_syntax_error ( $yymajor, $yytokenvalue );
					}
					$this->yyerrcnt = 3;
					$this->yy_destructor ( $yymajor, $yytokenvalue );
					if ($yyendofinput) {
						$this->yy_parse_failed ();
					}
					$yymajor = self::YYNOCODE;
				}
			} else {
				$this->yy_accept ();
				$yymajor = self::YYNOCODE;
			}
		} while ( $yymajor != self::YYNOCODE && $this->yyidx >= 0 );
	}
}
?>